#include "core/ThreadPool.hpp"
#include "utils/Logger.hpp"

/**
 * @brief 线程池构造函数实现
 *
 * 初始化指定数量的工作线程，并启动它们等待任务
 */
ThreadPool::ThreadPool(size_t threads, size_t queueCapacity) : queueCapacity(queueCapacity) {
    for (size_t i = 0; i < threads; ++i) {
        workers.emplace_back([this] {
            while (true) {
                std::function<void()> task;
                {
                    std::unique_lock<std::mutex> lock(this->queue_mutex);
                    // 等待任务或关闭信号
                    this->condition.wait(lock, [this] {
                        return this->stop || !this->tasks.empty();
                        });
                    
                    if ((this->stop && this->tasks.empty()) || this->terminate) { // 线程退出条件
                        // 唤醒其他可能等待的线程
                        this->condition.notify_all();
                        return;
                    }

                    // 获取任务
                    task = std::move(this->tasks.front());
                    this->tasks.pop();

                    // 通知可能等待队列空间的线程
                    this->condition.notify_one();
                }

                // 执行任务
                ++this->activeCount;
                try {
                    task();
                } catch (const std::exception &e) {
                    LOG_ERROR(std::string("Exception in task: ") + e.what());
                }
                --this->activeCount;

                // 通知可能等待所有任务完成的线程
                this->condition.notify_all();
            }
            });
    }
}

/**
 * @brief 移动构造函数实现
 *
 * 转移另一个线程池的资源所有权
 */
ThreadPool::ThreadPool(ThreadPool &&other) noexcept
    : workers(std::move(other.workers)),
    tasks(std::move(other.tasks)),
    activeCount(other.activeCount.load()),
    stop(other.stop.load()),
    terminate(other.terminate.load()),
    queueCapacity(other.queueCapacity) {
    other.stop = true;
    other.terminate = true;
    other.condition.notify_all();
}

/**
 * @brief 移动赋值运算符实现
 *
 * 转移另一个线程池的资源所有权
 */
ThreadPool &ThreadPool::operator=(ThreadPool &&other) noexcept {
    if (this != &other) {
        shutdownNow();

        workers = std::move(other.workers);
        tasks = std::move(other.tasks);
        activeCount = other.activeCount.load();
        stop = other.stop.load();
        terminate = other.terminate.load();

        other.stop = true;
        other.terminate = true;
        other.condition.notify_all();
    }
    return *this;
}

/**
 * @brief 正常关闭线程池的实现
 *
 * 标记线程池为停止状态，等待所有已加入队列的任务完成
 */
void ThreadPool::shutdown() {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        if (stop) return;
        stop = true;
    }
    condition.notify_all(); // 通知所有线程检查停止标志

    // 等待所有任务完成
    std::unique_lock<std::mutex> lock(queue_mutex);
    condition.wait(lock, [this] { return tasks.empty() && activeCount == 0; });

    // 等待所有线程完成
    for (auto &worker : workers) {
        if (worker.joinable()) {
            worker.join();
        }
    }
}

/**
 * @brief 立即关闭线程池的实现
 *
 * 标记线程池为终止状态，清空任务队列，并等待当前执行的任务完成
 */
void ThreadPool::shutdownNow() {
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        if (terminate) return;
        stop = true;
        terminate = true;

        // 清空任务队列
        decltype(tasks) emptyQueue;
        std::swap(tasks, emptyQueue);
    }
    condition.notify_all(); // 通知所有线程检查终止标志

    // 等待所有线程完成当前任务
    for (auto &worker : workers) {
        if (worker.joinable()) {
            worker.join();
        }
    }
}

/**
 * @brief 获取当前活跃线程数的实现
 *
 * @return 当前正在执行任务的线程数量
 */
size_t ThreadPool::activeThreads() const {
    return activeCount.load();
}

/**
 * @brief 获取等待任务数的实现
 *
 * @return 任务队列中的任务数量
 */
size_t ThreadPool::waitingTasks() const {
    std::unique_lock<std::mutex> lock(queue_mutex);
    return tasks.size();
}

/**
 * @brief 检查线程池运行状态的实现
 *
 * @return true 线程池正在运行
 * @return false 线程池已停止
 */
bool ThreadPool::isRunning() const {
    return !stop.load();
}

/**
 * @brief 析构函数实现
 *
 * 确保线程池在销毁前被正确关闭
 */
ThreadPool::~ThreadPool() {
    if (!terminate) {
        shutdown();
    }
}